Learning Structured Constraint Models: a First Attempt

In this paper we give an overview of an early prototype which learns structured constraint models from flat, positive examples of solutions. It is based on previous work on a Constraint Seeker, which finds constraints in the global constraint catalog satisfying positive and negative examples. In the current tool we extend this system to find structured conjunctions of constraints on regular subsets of variables in the given solutions. Two main elements of the approach are a bi-criteria optimzation problem which finds conjunctions of constraints which are both regular and relevant, and a syntactic dominance check between conjunctions, which removes implied constraints without requiring a full theorem prover, using meta-data in the constraint catalog. Some initial experiments on a proof-ofconcept implementation show promising results. 1 Scope and Assumptions Global constraints were initially introduced [3] in order to more efficiently handle the filtering associated with some recurring structured constraint networks [1]. An inherent disadvantage of the approach is that the introduction of global constraints does not make using constraint programming any easier, since the growing number of global constraints presents confusing choices to most users. Based on this recognized concern about ease of use of constraint programming [13], this paper shows how global constraints can be, in the context of structured problems, an essential component to automatically learning models from example solutions. More precisely, this paper presents the sketch of a generic approach, as well as a proof of concept, for automatically extracting constraint models from a set of positive, flat samples, that relies both on global constraints and constraint programming. This work is done under the following five assumptions: 1. We assume that the samples directly correspond to solutions that one typically finds in standard magazines and/or standard Operations Research problems compendium for the corresponding problems, i.e., we do not require that samples are solutions of special, reformulated models of the original problem. ? The second author is supported by Science Foundation Ireland (Grant Numbers 05/IN/I886 and 10/IN.1/I3032). 2. Many problems are not defined completely just by a solution, they also involve some kind of additional data or hints, which are required in order to interpret the solution. This is the case both for a number of puzzles where hints are part of the problem statement, as well as for a number of Operations Research problems where data (e.g., a cost matrix in optimization problems, or durations and resource use of activities in scheduling problems) are also part of the problem definition. Within this paper, we restrict ourself to problems where, beside the positive samples, no extra hints are provided. 3. We assume that all positive samples are correct (i.e, there is no noise in the sample data). 4. All samples have the same size, i.e. we do not have to generalize the model found for arbitrary problem sizes. 5. We assume that we are looking at problems that have a strong internal structure, i.e., they can be represented in a very compact way. This is in fact the case for most problems considered by Constraint Programming, but is equally true for problem class repositories like Garey and Johnson [11]. Our approach takes advantage of assumptions 3. and 5., i.e., on the fact that our samples are reliable and that we restrict ourself to structured problems. It also relies on the following key ingredients: – First, it tries to express models as a limited number of conjunctions of similar global constraints. It uses the knowledge base describing various properties of global constraints provided by the global constraint catalog [2] in order to come up with constraints that are not only valid for the given samples, but also make sense for a human modeler. – Second, it relies on the global Constraint Seeker functionality [4] for retrieving and ranking relevant candidate constraints that can match a given combination of parameters obtained from the positive samples. – Third, it addresses the learning problem of a conjunction of constraints as a bicriteria optimization constraint search problem, where a conjunction of constraints can both be represented in a very compact way, and consists of constraints that are highly ranked by the Constraint Seeker. Section 2 provides an overview of the different components of our method. Section 3 will evaluate our method on some initial example problems, while Section 4 looks at related work. 2 Overview of the Learning Algorithm The learning algorithm is decomposed into the following successive steps: 1. Given V = v1, v2, . . . , vs variables, where s is the size of the samples, a groups of variables generator generates ordered sequences of variables of V on which we will search for constraints. The aim of this generator is to systematicaly propose different ways of grouping variables together, which can be both described concisely and which matches the pattern found in typical constraint models. One example is the matrix partition generator matrix(p, q, α, β) which interprets a sample of size s = p ∗ q as a p × q matrix, and extracts blocks of size α ∗ β from α rows and β columns. Another example is the diagonal generator which, for s = n ∗ n, extracts the two main diagonals of the n×n matrix. Other generators are described in http://4c.ucc.ie/ ̃hsimonis/modref11.pdf, which also contains a more detailed description of the other components of our tool. 2. The instance generator takes as input the samples as well as the ordered sequences of variables generated by the groups of variables generator. From this input it generates the ground parameters that will be passed to the Constraint Seeker [4] in order to retrieve the corresponding matching constraints. Since this part is quite straightforward it will not be detailed here. 3. For each sequence of variables the candidate generator takes the corresponding ground parameters built by the instance generator and calls the Constraint Seeker to find relevant constraint candidates. The details of this operation are described in [4]. 4. Once the candidate generator has generated a set of candidate constraints for each element of the ordered collection of sequences of variables, we call the relevance optimizer on each such collection. Its purpose is to find out for each ordered collection of sequences of variables one or several conjunctions of constraints that consist of both highly relevant and concisely described, structured sets of constraints. This step is done by solving a bi-criteria constraint optimization problem. One of the criteria is the regularity of the set of constraints. We prefer sequences which change only a few times, or which have a periodic structure with a short period. We can express this regularity by representing the constraint alternatives by integer indices, and then expressing change or period constraints over possible integer sequences. For each selected constraint we also know its rank in the Constraint Seeker output, which can be linked to the constraint index by element constraints. For a sequence of constraints, the rank is defined as the sum of the ranks of its constraints. These two criteria are incomparable, the resulting problem is therefore treated as a multi-criteria optimization problem. 5. Given a set of conjunctions of constraints found by the relevance optimizer, the dominance checker discards conjunctions that are implied by other conjunctions. As checking for implications between arbitrary sets of constraints is hard even for a full-featured theorem prover, we use a weaker domination criteria, based on metadata in the constraint catalog. Key concepts besides implication are contractible and expendible. A constraint is contractible w.r.t. to one of its arguments, if we can remove any variable from that argument in a solution, and still obtain a solution. The alldifferent constraint for example is contractible. A constraint is expendible if we can add any value to an argument in a solution, and still obtain a solution. The atleast constraint is extensible. Used together with meta-data about implications, we can now check if one set of constraints is dominated (and therefore implied) by another one, based on a simple, syntactic check.